/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Game;

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Random;
import javax.swing.JOptionPane;
//import javax.swing.JOptionPane;

/**
 *
 * @author VO CHI DUNG
 */
public class Player {

    private String Name;
    private ArrayList<MyCard> ListCurrentCard;
    private ArrayList<MyCard> ListReceivedCard;
    private int Score;
    private boolean bHasTurn;
    private boolean bHasInitTurn;
    private Point PosToDraw;
    private Dimension CardsDistance;

    public Player() {
        Name = "";
        ListCurrentCard = new ArrayList<MyCard>();
        ListReceivedCard = new ArrayList<MyCard>();
        Score = 0;
        bHasTurn = false;
        bHasInitTurn = false;
        PosToDraw = new Point(0, 0);
        CardsDistance = new Dimension(0, 0);
    }

    public void addCard(MyCard card) {
        if (ListCurrentCard.size() != 13) {
            ListCurrentCard.add(card);
        } else {
            initCardsPos();
        }
    }

    public boolean HasTwoClud() {
        for (int i = 0; i < getListCurrentCard().size(); i++) {
            if (ListCurrentCard.get(i).getNumberCard() == 2
                    && ListCurrentCard.get(i).getTypeCard() == 2) {
                return true;
            }
        }
        return false;
    }

    public void reset() {
//        ListCurrentCard.removeAll(ListCurrentCard);
//        ListReceivedCard.removeAll(ListReceivedCard);
//        for (int i = 0; i < ListCurrentCard.size(); i++) {
//            ListCurrentCard.remove(i);
//        }
        for (int i = 0; i < ListReceivedCard.size(); i++) {
            ListReceivedCard.remove(i);
        }
        nCardUpdate = 0;
        UpdatedCard = false;
    }

    public MyCard sendCardTowClud() {
        // Nếu có 2 chuồn thì send 2 chuồn trước
        if (HasTwoClud()) {
            for (int i = 0; i < ListCurrentCard.size(); i++) {
                if (ListCurrentCard.get(i).getNumberCard() == 2
                        && ListCurrentCard.get(i).getTypeCard() == 2) {
                    return ListCurrentCard.get(i);
                }
            }
        }
        return null;
    }

    public boolean isHasTypeCard(int typeCard) {
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getTypeCard() == typeCard) {
                return true;
            }
        }
        return false;
    }

    public void updateScore(int score) {
        this.setScore(this.getScore() + score);
    }

    public boolean isEmptyListCard() {
        if (ListCurrentCard.size() == 0) {
            return true;
        }
        return false;
    }

    public void updateCardReceive(MyCard card) {
        getListReceivedCard().add(card);
    }

    /**
     * @return the name
     */
    public String getName() {
        return Name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.Name = name;
    }

    /**
     * @return the ListCurrentCard
     */
    public ArrayList<MyCard> getListCurrentCard() {
        return ListCurrentCard;
    }

    /**
     * @param ListCurrentCard the ListCurrentCard to set
     */
    public void setListCurrentCard(ArrayList<MyCard> ListCardCurrent) {
        this.ListCurrentCard = ListCardCurrent;
    }

    /**
     * @return the ListReceivedCard
     */
    public ArrayList<MyCard> getListReceivedCard() {
        return ListReceivedCard;
    }

    /**
     * @param ListReceivedCard the ListReceivedCard to set
     */
    public void setListReceivedCard(ArrayList<MyCard> ListReceivedCard) {
        this.ListReceivedCard = ListReceivedCard;
    }

    /**
     * @return the Score
     */
    public int getScore() {
        return Score;
    }

    /**
     * @param Score the Score to set
     */
    public void setScore(int Score) {
        this.Score = Score;
    }

    /**
     * @return the bHasTurn
     */
    public boolean isbHasTurn() {
        return bHasTurn;
    }

    /**
     * @param bHasTurn the bHasTurn to set
     */
    public void setbHasTurn(boolean bHasTurn) {
        this.bHasTurn = bHasTurn;
    }

    /**
     * @return the bHasInitTurn
     */
    public boolean isbHasInitTurn() {
        return bHasInitTurn;
    }

    /**
     * @param bHasInitTurn the bHasInitTurn to set
     */
    public void setbHasInitTurn(boolean bHasInitTurn) {
        this.bHasInitTurn = bHasInitTurn;
    }

    /**
     * @return the PosToDraw
     */
    public Point getPosToDraw() {
        return PosToDraw;
    }

    /**
     * @param PosToDraw the PosToDraw to set
     */
    public void setPosToDraw(Point PosToDraw) {
        this.PosToDraw = PosToDraw;
    }

    /**
     * @return the CardsDistance
     */
    public Dimension getCardsDistance() {
        return CardsDistance;
    }

    /**
     * @param CardsDistance the CardsDistance to set
     */
    public void setCardsDistance(Dimension CardsDistance) {
        this.CardsDistance = CardsDistance;
    }

    //////////////////////////////////////////////////
    // Code for drawing of player
    //////////////////////////////////////////////////
    public void ChangeBackCards() {
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            ListCurrentCard.get(i).changeBackCardImage();
        }
    }

    public void initCardsPos() {
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            Point newPos = new Point(
                    i * CardsDistance.width + PosToDraw.x,
                    i * CardsDistance.height + PosToDraw.y);
            //ListCurrentCard.get(i).setPosition(newPos);
            ListCurrentCard.get(i).setEndPosition(newPos);
        }
    }

    public int nCardUpdate = 0;    // so card duoc update
    public boolean  UpdatedCard = false;

    public void Update()
    {
        if (nCardUpdate < ListCurrentCard.size())
        {
            ListCurrentCard.get(nCardUpdate).Update();
            UpdatedCard = false;

            // Neu card da toi dich thi tiep tuc card khac
            Point p1 = ListCurrentCard.get(nCardUpdate).getEndPosition();
            Point p2 = ListCurrentCard.get(nCardUpdate).getPosition();
            if (p1.x == p2.x && p1.y == p2.y)
            {
                nCardUpdate++;
                UpdatedCard = true;
            }
        }

//        for (int i = 0; i < ListCurrentCard.size(); i++)
//            ListCurrentCard.get(i).Update();
    }

    public void Draw(Graphics g) 
    {
        int n = Math.min(nCardUpdate, ListCurrentCard.size() - 1);
        for (int i = 0; i <= n; i++)
            ListCurrentCard.get(i).Draw(g);


//        for (int i = 0; i < ListCurrentCard.size(); i++)
//            ListCurrentCard.get(i).Draw(g);
    }


    public void processCursor(int x, int y) {
        //ArrayList<MyCard> listCard = ArrayPlayer[0].getListCardCurrent();
        for (int i = 0; i < ListCurrentCard.size() - 1; i++) {
            ListCurrentCard.get(i).processCursor(x, y,
                    GlobalSettings.CardsDistances[0].width,
                    GlobalSettings.CardHeight);
        }
        ListCurrentCard.get(ListCurrentCard.size() - 1).processCursor(x, y);
    }

        
    public MyCard processCardSend()
    {
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getState() == 1) {
                return ListCurrentCard.get(i);
            }
        }

        return null;
    }

    public MyCard AutoSendCard() {
        Random random = new Random();
        return ListCurrentCard.get(random.nextInt(ListCurrentCard.size()));
    }

    public void removeCardInListCurrentCard(MyCard card) {
        int indexCard = 0;
        Point prevPoint = new Point();
        for (; indexCard < ListCurrentCard.size(); indexCard++) {
            if (ListCurrentCard.get(indexCard).equalCard(card)) {
                prevPoint = ListCurrentCard.get(indexCard).getPosition();
                ListCurrentCard.remove(indexCard);
                break;
            }
        }
        for(;indexCard < ListCurrentCard.size(); indexCard++)
        {
            Point temp = new Point(prevPoint);
            prevPoint = ListCurrentCard.get(indexCard).getPosition();
            ListCurrentCard.get(indexCard).setPosition(temp);
        }
    }

    public MyCard AutoSendCard(int typeCard) {
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getTypeCard() == typeCard) {
                return ListCurrentCard.get(i);
            }
        }
        return ListCurrentCard.get(0);
    }

    public MyCard computerAlgorithmEasy(int typeCardOfFirstPlayer,
            boolean isPlayFirstTurn,
            boolean isBrokenHeart) {
        // Máy là người đánh đâu tiên
        if (isPlayFirstTurn) {
//            // Trái tim bị vỡ
//            if (isBrokenHeart) {
//                // Có nước cơ nhỏ hơn 7
//                if (isHasHeartLessSeven()) {
//                    // đánh lá bài nước cơ nhỏ nhất
//                    return sendLeastCard(0, true);
//                } else // không có nước cơ nhỏ hơn 7
//                {
//                    // đánh lá bài nhỏ nhất
//                    return sendLeastCard();
//                }
//            } //Trái tim chưa bị vỡ
//            else {
//                // đánh lá bài nhỏ nhất nhưng không phải là nước cơ
//                return sendLeastCard(0, false);
//            }
            return processSendCardComputerPlayFirstTurn(isBrokenHeart);
        } // Máy không là người đánh đầu tiên
        else {
//            // Máy có kiểu bài của người chơi đầu tiên
//            if (isHasTypeCard(typeCardOfFirstPlayer)) {
//                // nếu kiểu bài là nước cơ
//                if (typeCardOfFirstPlayer == 0) {
//                    return sendLeastCard(0, true);
//                } else {
//                    return sendLargestCard(typeCardOfFirstPlayer);
//                }
//            } else {
//                // Có Q bích
//                MyCard card = sendQueenOfSpades();
//                if (card != null) {
//                    return sendQueenOfSpades();
//                } else {
//                    // Có nước cơ
//                    if (isHasTypeCard(0)) {
//                        return sendLargestCard(0);
//                    } else {
//                        return sendLargestCard();
//                    }
//                }
//            }
            return processSendCardComputerNoPlayFirstTurn(typeCardOfFirstPlayer);
        }
    }

    private MyCard processSendCardComputerPlayFirstTurn(boolean isBrokenHeart) {
        if (isBrokenHeart) {
            // Có nước cơ nhỏ hơn 7
            if (isHasHeartLessSeven()) {
                // đánh lá bài nước cơ nhỏ nhất
                return sendLeastCard(0, true);
            } else // không có nước cơ nhỏ hơn 7
            {
                // đánh lá bài nhỏ nhất
                return sendLeastCard();
            }
        } //Trái tim chưa bị vỡ
        else {
            // đánh lá bài nhỏ nhất nhưng không phải là nước cơ
            return sendLeastCard(0, false);
        }
    }

    private MyCard processSendCardComputerNoPlayFirstTurn(int typeCardOfFirstPlayer) {
        // Máy có kiểu bài của người chơi đầu tiên
        if (isHasTypeCard(typeCardOfFirstPlayer)) {
//            // nếu kiểu bài là nước cơ
//            if (typeCardOfFirstPlayer == 0) {
//                return sendLeastCard(0, true);
//            } else {
//                return sendLargestCard(typeCardOfFirstPlayer);
//            }
            return processSendCardComputerHasTypeCardOfFirstPlayer(typeCardOfFirstPlayer);
        } else {
//            // Có Q bích
//            MyCard card = sendQueenOfSpades();
//            if (card != null) {
//                return sendQueenOfSpades();
//            } else {
//                // Có nước cơ
//                if (isHasTypeCard(0)) {
//                    return sendLargestCard(0);
//                } else {
//                    return sendLargestCard();
//                }
//            }
            return processSendCardComputerNoHasTypeCardOfFirstPlayer();
        }
    }

    private MyCard processSendCardComputerNoPlayFirstTurn(
            MyCard[] ArrayReceivedCard,
            int typeCardOfFirstPlayer) {
        // Máy có kiểu bài của người chơi đầu tiên
        if (isHasTypeCard(typeCardOfFirstPlayer)) {
            return processSendCardComputerHasTypeCardOfFirstPlayer(ArrayReceivedCard,typeCardOfFirstPlayer);
            //return null;
        } else {
            return processSendCardComputerNoHasTypeCardOfFirstPlayer();
        }
    }

    private MyCard processSendCardComputerHasTypeCardOfFirstPlayer(int typeCardOfFirstPlayer) {
        // nếu kiểu bài là nước cơ
        if (typeCardOfFirstPlayer == 0) {
            return sendLeastCard(0, true);
        } else {
            return sendLargestCard(typeCardOfFirstPlayer);
        }
    }

    private MyCard processSendCardComputerHasTypeCardOfFirstPlayer(
            MyCard[] ArrayReceivedCard,
            int typeCardOfFirstPlayer) {
        MyCard card = getCardLagrestInArrayByType(ArrayReceivedCard, typeCardOfFirstPlayer);
        boolean isLastTurn = isLastTurn(ArrayReceivedCard);
        int index = getIndexLagrestCardInCardsLess(card);
        // nếu kiểu bài người đầu tiên là nước cơ
        if (typeCardOfFirstPlayer == 0) {
            return DoSomeThing(typeCardOfFirstPlayer,index,isLastTurn);
        } else {// nếu kiểu bài người đầu tiên không là nước cơ
            if (isArrayHasSpadeQueen(ArrayReceivedCard) || isArrayHasHeart(ArrayReceivedCard)) {
                return DoSomeThing(typeCardOfFirstPlayer,index,isLastTurn);
            } else {
                // Đánh lá bài lớn nhất nhưng không phải Q bích cùng kiểu với người chơi đầu tiên
                return sendLargestCardNoSpadeQueen(typeCardOfFirstPlayer);
            }
        }
    }

    private MyCard DoSomeThing(int typeCardOfFirstPlayer, int index, boolean isLastTurn) {
        // Là người đánh cuối cùng
        if (isLastTurn) {
            if (index >= 0) {
                return ListCurrentCard.get(index);
            } else {
                return sendLargestCard(typeCardOfFirstPlayer);
            }
        } else { // không là người đánh cuối cùng
            if (index >= 0) {
                return ListCurrentCard.get(index);
            } else {
                return sendLeastCard(typeCardOfFirstPlayer, true);
            }
        }
    }

    private MyCard processSendCardComputerNoHasTypeCardOfFirstPlayer() {
        MyCard card = sendQueenOfSpades();
        if (card != null) {
            return card;
        } else {
            // Có nước cơ
            if (isHasTypeCard(0)) {
                return sendLargestCard(0);
            } else {
                return sendLargestCard();
            }
        }
    }

    private boolean isHasHeartLessSeven() {
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getTypeCard() == 0
                    && ListCurrentCard.get(i).getNumberCard() < 7) {
                return true;
            }
        }
        return false;
    }

    private MyCard sendLeastCardByType(int typeCardOfFirstPlayer) {
        MyCard card = new MyCard();
        card.setNumberCard(13);
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getTypeCard() == typeCardOfFirstPlayer
                    && ListCurrentCard.get(i).getNumberCard() <= card.getNumberCard()) {
                card = ListCurrentCard.get(i);
            }
        }
        return card;
    }

    private MyCard sendLeastCard() {
        MyCard card = ListCurrentCard.get(0);
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getNumberCard() < card.getNumberCard()) {
                card = ListCurrentCard.get(i);
            }
        }
        return card;
    }

    private MyCard sendLeastCardNoType(int typeCardOfFirstPlayer) {
        MyCard card = new MyCard();
        card.setNumberCard(13);
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getTypeCard() != typeCardOfFirstPlayer
                    && ListCurrentCard.get(i).getNumberCard() <= card.getNumberCard()) {
                card = ListCurrentCard.get(i);
            }
        }
        return card;
    }

    /*
     * Lấy về lá bài nhỏ nhất
     * typeCardOfFirstPlayer: kiểu lá bài của người chơi đầu tiên trong lượt
     *             Nếu  kiểu nằm ngoài dãy (0-4) => trả về lá nhỏ nhất 
     * isSameType: Nếu  true thì trả về lá bài nhỏ nhất cùng kiểu với lá người đầu tiên
     *                  false thì trả về lá bài nhỏ nhất khác kiểu với lá người đầu tiên
     */
    private MyCard sendLeastCard(int typeCardOfFirstPlayer, boolean isSameType) {
        if (typeCardOfFirstPlayer < 0 || typeCardOfFirstPlayer > 3) {
            return sendLeastCard();
        } else if (isSameType) {
            return sendLeastCardByType(typeCardOfFirstPlayer);
        } else {
            return sendLeastCardNoType(typeCardOfFirstPlayer);
        }
    }

    private MyCard sendQueenOfSpades() {
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getNumberCard() == 12
                    && ListCurrentCard.get(i).getTypeCard() == 3) {
                return ListCurrentCard.get(i);
            }
        }
        return null;
    }

    private MyCard sendLargestCard() {
        MyCard card = ListCurrentCard.get(0);
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getNumberCard() > card.getNumberCard()) {
                card = ListCurrentCard.get(i);
            }
        }
        return card;
    }

    private MyCard sendLargestCardNoSpadeQueen(int typeCardOfFirstPlayer) {
        MyCard card = new MyCard();
        card.setNumberCard(1);
        card.setTypeCard(-1);
        MyCard cardSpadeQueen = new MyCard();
        cardSpadeQueen.setNumberCard(12);
        cardSpadeQueen.setTypeCard(3);
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getNumberCard() >= card.getNumberCard()
                    && ListCurrentCard.get(i).getTypeCard() == typeCardOfFirstPlayer
                    && !ListCurrentCard.get(i).equalCard(cardSpadeQueen)) {
                card = ListCurrentCard.get(i);
            }
        }
        // Tránh trường hợp bài chỉ còn Q bích là cùng nước với người đánh đầu tiên
        if (card.getTypeCard() == -1) {
            return sendLargestCard(typeCardOfFirstPlayer);
        }
        return card;
    }

    private MyCard sendLargestCardByType(int typeCard) {
        MyCard card = new MyCard();
        card.setNumberCard(1);
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getNumberCard() >= card.getNumberCard()
                    && ListCurrentCard.get(i).getTypeCard() == typeCard) {
                card = ListCurrentCard.get(i);
            }
        }
        return card;
    }

    /*
     * Trả về lá bài lớn nhất
     * typeCardOfFirstPlayer: 
     *  Nếu:   nằm trong dãy (0-4) => trả về lá lớn nhất cùng kiểu typeCardOfFirstPlayer
     *         ngược lại trả về lá lớn nhất
     */
    private MyCard sendLargestCard(int typeCard) {
        if (typeCard < 0 || typeCard > 3) {
            return sendLargestCard();
        } else {
            return sendLargestCardByType(typeCard);
        }
    }

    public MyCard computerAlgorithmNormal(MyCard[] ArrayReceivedCard, int typeCardOfFirstPlayer, boolean isPlayFirstTurn, boolean isBrokenHeart) {

        // Máy là người đánh đâu tiên
        if (isPlayFirstTurn) {
            return processSendCardComputerPlayFirstTurn(isBrokenHeart);
        }
        else
        {
            return processSendCardComputerNoPlayFirstTurn(ArrayReceivedCard,typeCardOfFirstPlayer);
            // Máy có kiểu bài của người đánh đầu tiên
                // First Player đánh nước heart
                    // Máy là người đánh cuối cùng
                    // Máy không là người đánh cuối cùng
                // First Player không đánh nước heart
                    // Mảng nhưng người đã đánh có nước cơ or Q bích
                        // Máy là người đánh cuối cùng
                            // Nếu có lá mà nhỏ hơn lá lớn nhất của những người chơi đã đánh mà cùng với người đầu tiên thì đánh lá lớn nhất trong những lá nhỏ hơn đó.
                            // Đánh lá lớn nhất
                        // Máy không là người đánh cuối cùng
                            // Nếu có lá mà nhỏ hơn lá lớn nhất của những người chơi đã đánh mà cùng với người đầu tiên thì đánh lá lớn nhất trong những lá nhỏ hơn đó.
                            // Đánh lá nhỏ nhất
                    // Mảng nhưng người đã đánh không có nước cơ or Q bích
                        // Đánh nước lớn nhất nhưng không phải là đầm bích. (nếu là nước bích)
            // Máy không có kiểu bài của người đánh đầu tiên
        }
    }

    private boolean isArrayHasHeart(MyCard[] ArrayReceivedCard) {
        for (int i = 0; i < ArrayReceivedCard.length; i++) {
            if (ArrayReceivedCard[i] != null) {
                if (ArrayReceivedCard[i].getTypeCard() == 0) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean isArrayHasSpadeQueen(MyCard[] ArrayReceivedCard) {
        MyCard card = new MyCard();
        card.setNumberCard(12);
        card.setTypeCard(3);
        for (int i = 0; i < ArrayReceivedCard.length; i++) {
            if(ArrayReceivedCard[i]!=null){
                if (ArrayReceivedCard[i].equalCard(card)) {
                return true;
                }
            }
        }
        return false;
    }

    private MyCard getCardLagrestInArrayByType(
            MyCard[] ArrayReceivedCard,
            int typeCardOfFirstPlayer) {
        MyCard card = new MyCard();
        card.setNumberCard(1);
        for (int i = 0; i < ArrayReceivedCard.length; i++) {
            if (ArrayReceivedCard[i] != null) {
                if (ArrayReceivedCard[i].getNumberCard() > card.getNumberCard())
                        if(ArrayReceivedCard[i].getTypeCard() == typeCardOfFirstPlayer) {
                    card = ArrayReceivedCard[i];
                }
            }
        }
        return card;
    }

    private boolean isLastTurn(MyCard[] ArrayReceivedCard) {
        int count = 0;
        for (int i = 0; i < ArrayReceivedCard.length; i++) {
            if (ArrayReceivedCard[i]!=null) {
                count++;
            }
        }
        if (count == 3) {
            return true;
        }
        return false;
    }

    private int getIndexLagrestCardInCardsLess(MyCard card) {
        int index = -1;
        MyCard cardTemp = new MyCard();
        cardTemp.setNumberCard(14);
        for (int i = 0; i < ListCurrentCard.size(); i++) {
            if (ListCurrentCard.get(i).getTypeCard() == card.getTypeCard()
                    && ListCurrentCard.get(i).getNumberCard() < card.getNumberCard()
                    && ListCurrentCard.get(i).getNumberCard() < cardTemp.getNumberCard()) {
                index = i;
            }
        }
        return index;
    }

    public MyCard computerAlgorithmHard() {
        return null;
    }

    public MyCard computerPlay(
            MyCard[] ArrayReceivedCard, // Mảng bài những người chơi đã đánh trong 1 lượt
            int typeCardOfFirstPlayer,  // kiểu bài của người chơi đầu tiên
            boolean isPlayFirstTurn,    // người chơi có phải là người đánh đầu tiên không
            boolean isBrokenHeart,      // kiểm tra trái tim có bị vỡ chưa
            int computerlevel)          // mức độ chơi của máy
                                        //  1: Dễ
                                        //  2 hoặc khác 1,3: trung bình
                                        //  3: khó
    {
        try{
        switch (computerlevel) {
            case 1:
                return computerAlgorithmEasy(typeCardOfFirstPlayer, isPlayFirstTurn, isBrokenHeart);
            case 2:
                return computerAlgorithmNormal(ArrayReceivedCard, typeCardOfFirstPlayer, isPlayFirstTurn, isBrokenHeart);
            case 3:
                return computerAlgorithmHard();
            default:
                return computerAlgorithmNormal(ArrayReceivedCard, typeCardOfFirstPlayer, isPlayFirstTurn, isBrokenHeart);
        }
        }
        catch(Exception ex)
        {
            JOptionPane.showMessageDialog(null, ex.getMessage());
            return null;
        }
    }

    public void sortListCard()
    {
        for(int i=0;i<ListCurrentCard.size()-1;i++)
            for(int j=i+1;j<ListCurrentCard.size();j++)
            {
                if (ListCurrentCard.get(j).lessCard(ListCurrentCard.get(i))) {
                    // Hoan Vi
                    MyCard temp = new MyCard();
                    temp.setNumberAndType(ListCurrentCard.get(j));
                    ListCurrentCard.get(j).setNumberAndType(ListCurrentCard.get(i));
                    ListCurrentCard.get(i).setNumberAndType(temp);
                }
            }
    }

}
